﻿#include "D3D9ZhongWen.h"

#pragma region _通用基类
	template<typename T原生接口, typename T关联设备接口>
	HRESULT _通用基类<T原生接口, T关联设备接口>::查询接口(REFIID 接口标识, void** 输出接口)
	{
		return m_p原生接口->QueryInterface(接口标识, 输出接口);
	}

	template<typename T原生接口, typename T关联设备接口>
	UINT _通用基类<T原生接口, T关联设备接口>::增加引用()
	{
		return m_p原生接口->AddRef();
	}

	template<typename T原生接口, typename T关联设备接口>
	UINT _通用基类<T原生接口, T关联设备接口>::释放资源()
	{
		return m_p原生接口->Release();
	}

	template<typename T原生接口, typename T关联设备接口>
	T关联设备接口* _通用基类<T原生接口, T关联设备接口>::获取关联设备()
	{
		// 调用后将增加关联设备计数！
		// 在使用完毕后请自行调用设备指针->释放资源()。
		// 否则可能影响COM计数与销毁。
        if(!m_p关联设备)return nullptr;
		m_p关联设备->增加引用();
		return m_p关联设备;
	}
	template<>
	void* _通用基类<IDirect3D9, void>::获取关联设备()
	{
		return NULL;
	}
	template<>
	void* _通用基类<IDirect3D9Ex, void>::获取关联设备()
	{
		return NULL;
	}

	template<typename T原生接口, typename T关联设备接口>
	T原生接口* _通用基类<T原生接口, T关联设备接口>::⚠获取原生指针()
	{
		// 警告：
		//  此方法仅用于DX9中文封装库内部使用。
		//  在部分函数需求原生接口时调用。
		//  请不要在程序中使用此方法。
		//  此方法可能会在未来的版本中被删除。
		//  因为仅用于内部使用，
		//  所以不会增加关联设备计数。
		if(!m_p原生接口)return nullptr;
		return m_p原生接口;
	}
// _通用基类
#pragma endregion

#pragma region _显卡管理器基类
	template<typename T原生接口>
	bool _显卡管理器基类<T原生接口>::初始化(UINT SDK版本)
	{
		m_p原生接口 = Direct3DCreate9(SDK版本);
		if(!m_p原生接口)return false;
		return true;
	}
	template<>
	bool _显卡管理器基类<IDirect3D9Ex>::初始化(UINT SDK版本号)
	{
		if(m_p原生接口)return false;
		
		return (bool)(Direct3DCreate9Ex(
			SDK版本号,
			&m_p原生接口
		));
	}


	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::注册软件设备(void* 初始化函数指针){
		return m_p原生接口->RegisterSoftwareDevice(初始化函数指针);
	}

	template<typename T原生接口>
	UINT _显卡管理器基类<T原生接口>::获取显卡数量()const {
		return m_p原生接口->GetAdapterCount();
	}

	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::获取显卡标识(
		UINT 显卡索引, 
		DWORD 标志, 
		显卡信息* 输出信息
	){
		return m_p原生接口->GetAdapterIdentifier(显卡索引, 标志, (D3DADAPTER_IDENTIFIER9*)输出信息);
	}

	template<typename T原生接口>
	UINT _显卡管理器基类<T原生接口>::获取显示模式数量(
		UINT 显卡索引 , 
		像素格式 格式
	)const {
		return m_p原生接口->GetAdapterModeCount(显卡索引, (D3DFORMAT)格式);
	}

	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::枚举显示模式(
		UINT 显卡索引, 
		像素格式 格式, 
		UINT 模式索引, 
		显示模式* 输出模式
	){
		return m_p原生接口->EnumAdapterModes(显卡索引, (D3DFORMAT)格式, 模式索引, (D3DDISPLAYMODE*)输出模式);
	}

	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::获取当前显示模式(
		UINT 显卡索引, 
		显示模式* 输出模式
	){
		return m_p原生接口->GetAdapterDisplayMode(显卡索引, (D3DDISPLAYMODE*)输出模式);
	}

	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::检查设备类型兼容性(
		UINT 显卡索引, 
		设备类型 设备类型, 
		像素格式 显卡格式, 
		像素格式 后台缓冲格式, 
		BOOL 窗口化模式
	){
		return m_p原生接口->CheckDeviceType(
			显卡索引, (D3DDEVTYPE)设备类型 , 
			(D3DFORMAT)显卡格式, (D3DFORMAT)后台缓冲格式 , 
			窗口化模式
		);
	}

	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::检查设备格式支持(
		UINT 显卡索引, 
		设备类型 设备类型, 
		像素格式 显卡格式, 
		DWORD 用途标志, 
		资源类型 资源类型, 
		像素格式 检查格式
	){
		return m_p原生接口->CheckDeviceFormat(
			显卡索引, (D3DDEVTYPE)设备类型, (D3DFORMAT)显卡格式, 
			用途标志, (D3DRESOURCETYPE)资源类型, (D3DFORMAT)检查格式
		);
	}

	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::检查多重采样支持(
		UINT 显卡索引, 
		设备类型 设备类型, 
		像素格式 表面格式, 
		BOOL 窗口化模式, 
		多重采样类型 采样类型, 
		DWORD* 输出质量等级
	){
		return m_p原生接口->CheckDeviceMultiSampleType(
			显卡索引, (D3DDEVTYPE)设备类型, (D3DFORMAT)表面格式,
			窗口化模式, (D3DMULTISAMPLE_TYPE)采样类型, 输出质量等级
		);
	}

	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::检查深度模板匹配(
		UINT 显卡索引, 
		设备类型 设备类型, 
		像素格式 显卡格式, 
		像素格式 渲染目标格式, 
		像素格式 深度模板格式
	){
		return m_p原生接口->CheckDepthStencilMatch(
			显卡索引, (D3DDEVTYPE)设备类型, 
			(D3DFORMAT)显卡格式, (D3DFORMAT)渲染目标格式, (D3DFORMAT)深度模板格式
		);
	}

	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::检查格式转换支持(
		UINT 显卡索引, 
		设备类型 设备类型, 
		像素格式 源格式, 
		像素格式 目标格式
	){
		return m_p原生接口->CheckDeviceFormatConversion(
			显卡索引, (D3DDEVTYPE)设备类型, (D3DFORMAT)源格式, (D3DFORMAT)目标格式
		);
	}

	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::获取设备能力(
		UINT 显卡索引, 
		设备类型 设备类型, 
		设备能力* 输出能力描述
	){
		return m_p原生接口->GetDeviceCaps(
			显卡索引, (D3DDEVTYPE)设备类型, (D3DCAPS9*)输出能力描述
		);
	}

	template<typename T原生接口>
	HMONITOR _显卡管理器基类<T原生接口>::获取显卡显示器(
		UINT 显卡索引
	)const {
		return m_p原生接口->GetAdapterMonitor(显卡索引);
	}

	template<typename T原生接口>
	HRESULT _显卡管理器基类<T原生接口>::创建设备(
		UINT 显卡索引, 
		设备类型 设备类型, 
		HWND 焦点窗口, 
		DWORD 行为标志, 
		呈现参数* 呈现参数, 
		_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<T原生接口>>** pp输出设备
	)
	{
		
		IDirect3DDevice9* pDevice= nullptr;
		HRESULT returns = m_p原生接口->CreateDevice(
			显卡索引, (D3DDEVTYPE)设备类型, 焦点窗口,
			行为标志, (D3DPRESENT_PARAMETERS*)呈现参数, &pDevice
		);
		if(pDevice)
		{
			_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<T原生接口>>* 设备 = new _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<T原生接口>>(pDevice, this);
			if(!设备)
			{
				pDevice->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出设备 = 设备;
		}
		return returns;
	}
//_显卡管理器基类
#pragma endregion

#pragma region _显卡设备基类
	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::检测设备状态()
	{
		return m_p原生接口->TestCooperativeLevel();
	}

	template<typename T原生接口, typename T关联设备接口>
	UINT _显卡设备基类<T原生接口, T关联设备接口>::获取可用显存()const {
		return m_p原生接口->GetAvailableTextureMem();
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::释放托管资源()
	{
		return m_p原生接口->EvictManagedResources();
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取设备能力(
		设备能力* 能力描述
	)
	{
		return m_p原生接口->GetDeviceCaps((D3DCAPS9*)能力描述);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取显示模式(
		UINT 交换链索引,
		显示模式* 显示模式
	)
	{
		return m_p原生接口->GetDisplayMode(
			交换链索引, (D3DDISPLAYMODE*)显示模式
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取创建参数(
		设备创建参数* 创建参数
	)
	{
		return m_p原生接口->GetCreationParameters((D3DDEVICE_CREATION_PARAMETERS*)创建参数);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置光标属性(
		UINT x,
		UINT y,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 光标位图
	)
	{
		return m_p原生接口->SetCursorProperties(
			x, y, 光标位图->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	void _显卡设备基类<T原生接口, T关联设备接口>::设置光标位置(
		UINT x,
		UINT y,
		DWORD 标志
	)
	{
		m_p原生接口->SetCursorPosition(x, y, 标志);
	}

	template<typename T原生接口, typename T关联设备接口>
	BOOL _显卡设备基类<T原生接口, T关联设备接口>::显示光标(
		BOOL 是否显示
	)
	{
		return m_p原生接口->ShowCursor(是否显示);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建额外交换链(
		呈现参数* 呈现参数,
		_交换链基类<IDirect3DSwapChain9, _显卡设备基类<T原生接口, T关联设备接口>>** pp交换链
	)
	{
		IDirect3DSwapChain9* pSwapChain= nullptr;
		HRESULT returns = m_p原生接口->CreateAdditionalSwapChain(
			(D3DPRESENT_PARAMETERS*)呈现参数, &pSwapChain
		);
		if(pSwapChain)
		{
			_交换链基类<IDirect3DSwapChain9, _显卡设备基类<T原生接口, T关联设备接口>>* 交换链 = new _交换链基类<IDirect3DSwapChain9, _显卡设备基类<T原生接口, T关联设备接口>>(pSwapChain, this);
			if(!交换链)
			{
				pSwapChain->Release();
				return E_OUTOFMEMORY;
			}
			*pp交换链 = 交换链;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取交换链(
		UINT 交换链索引,
		_交换链基类<IDirect3DSwapChain9, _显卡设备基类<T原生接口, T关联设备接口>>** pp交换链
	)
	{
		IDirect3DSwapChain9* pSwapChain= nullptr;
		HRESULT returns = m_p原生接口->GetSwapChain(
			交换链索引, &pSwapChain
		);
		if(pSwapChain)
		{
			_交换链基类<IDirect3DSwapChain9, _显卡设备基类<T原生接口, T关联设备接口>>* 交换链 = new _交换链基类<IDirect3DSwapChain9, _显卡设备基类<T原生接口, T关联设备接口>>(pSwapChain, this);
			if(!交换链)
			{
				pSwapChain->Release();
				return E_OUTOFMEMORY;
			}
			*pp交换链 = 交换链;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	UINT _显卡设备基类<T原生接口, T关联设备接口>::获取交换链数量()const {
		return m_p原生接口->GetNumberOfSwapChains();
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::重置设备(呈现参数* 新呈现参数)
	{
		return m_p原生接口->Reset(
			(D3DPRESENT_PARAMETERS*)新呈现参数
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::呈现画面(
		const RECT* 源区域,
		const RECT* 目标区域,
		HWND 目标窗口,
		const RGNDATA* 脏区域
	)
	{
		return m_p原生接口->Present(
			源区域, 目标区域, 目标窗口,
			(RGNDATA*)脏区域
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取后台缓冲区(
		UINT 交换链索引,
		UINT 缓冲区索引,
		后台缓冲类型 缓冲类型,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns = m_p原生接口->GetBackBuffer(
			交换链索引, 缓冲区索引, (D3DBACKBUFFER_TYPE)缓冲类型, &pSurface
		);
		if(pSurface)
		{
			_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 显存表面 = new _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>(pSurface, nullptr, this);
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取光栅状态(
		UINT 交换链索引,
		光栅状态* 输出状态
	)
	{
		return m_p原生接口->GetRasterStatus(
			交换链索引, (D3DRASTER_STATUS*)输出状态
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置对话框模式(
		BOOL 启用对话框
	)
	{
		return m_p原生接口->SetDialogBoxMode(
			启用对话框
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	void _显卡设备基类<T原生接口, T关联设备接口>::设置伽马表(
		UINT 交换链索引,
		DWORD 标志,
		const 伽马斜坡* 伽马数据
	)
	{
		m_p原生接口->SetGammaRamp(
			交换链索引, 标志, (D3DGAMMARAMP*)伽马数据
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	void _显卡设备基类<T原生接口, T关联设备接口>::获取伽马表(
		UINT 交换链索引,
		伽马斜坡* 输出伽马数据
	)
	{
		m_p原生接口->GetGammaRamp(
			交换链索引, (D3DGAMMARAMP*)输出伽马数据
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建纹理(
		UINT 宽度,
		UINT 高度,
		UINT Mip层级,
		DWORD 用途,
		像素格式 格式,
		资源池类型 存储池,
		_平面纹理<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出纹理,
		HANDLE* 共享句柄= nullptr
	)
	{
		IDirect3DTexture9* pTexture= nullptr;
		HRESULT returns = m_p原生接口->CreateTexture(
			宽度, 高度, Mip层级,
			用途, (D3DFORMAT)格式, (D3DPOOL)存储池, &pTexture,
			共享句柄
		);
		if(pTexture)
		{
			_平面纹理<_显卡设备基类<T原生接口, T关联设备接口>>* 平面纹理 = new _平面纹理<_显卡设备基类<T原生接口, T关联设备接口>>(pTexture, this);
			if(!平面纹理)
			{
				pTexture->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出纹理 = 平面纹理;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建体积纹理(
		UINT 宽度,
		UINT 高度,
		UINT 深度,
		UINT Mip层级,
		DWORD 用途,
		像素格式 格式,
		资源池类型 存储池,
		_体积纹理<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出纹理,
		HANDLE* 共享句柄= nullptr
	)
	{
		IDirect3DVolumeTexture9* pTexture= nullptr;
		HRESULT returns = m_p原生接口->CreateVolumeTexture(
			宽度, 高度, 深度, Mip层级,
			用途, (D3DFORMAT)格式, (D3DPOOL)存储池, &pTexture,
			共享句柄
		);
		if(pTexture)
		{
			_体积纹理<_显卡设备基类<T原生接口, T关联设备接口>>* 体积纹理 = new _体积纹理<_显卡设备基类<T原生接口, T关联设备接口>>(pTexture, this);
			if(!体积纹理)
			{
				pTexture->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出纹理 = 体积纹理;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建立方体贴图(
		UINT 边长,
		UINT Mip层级,
		DWORD 用途,
		像素格式 格式,
		资源池类型 存储池,
		_立方体贴图<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出纹理,
		HANDLE* 共享句柄= nullptr
	)
	{
		IDirect3DCubeTexture9* pTexture= nullptr;
		HRESULT returns = m_p原生接口->CreateCubeTexture(
			边长, Mip层级,
			用途, (D3DFORMAT)格式, (D3DPOOL)存储池, &pTexture,
			共享句柄
		);
		if(pTexture)
		{
			_立方体贴图<_显卡设备基类<T原生接口, T关联设备接口>>* 立方体贴图 = new _立方体贴图<_显卡设备基类<T原生接口, T关联设备接口>>(pTexture, this);
			if(!立方体贴图)
			{
				pTexture->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出纹理 = 立方体贴图;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建顶点缓冲区(
		UINT 数据大小,
		DWORD 用途,
		DWORD FVF格式,
		资源池类型 存储池,
		_顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出缓冲区,
		HANDLE* 共享句柄= nullptr
	)
	{
		IDirect3DVertexBuffer9* pBuffer= nullptr;
		HRESULT returns = m_p原生接口->CreateVertexBuffer(
			数据大小,
			用途, FVF格式, (D3DPOOL)存储池, &pBuffer,
			共享句柄
		);
		if(pBuffer)
		{
			_顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>* 顶点缓冲区 = new _顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>(pBuffer, this);
			if(!顶点缓冲区)
			{
				pBuffer->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出缓冲区 = 顶点缓冲区;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建索引缓冲区(
		UINT 数据大小,
		DWORD 用途,
		像素格式 格式,
		资源池类型 存储池,
		_索引缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出缓冲区,
		HANDLE* 共享句柄= nullptr
	)
	{
		IDirect3DIndexBuffer9* pBuffer= nullptr;
		HRESULT returns = m_p原生接口->CreateIndexBuffer(
			数据大小,
			用途, (D3DFORMAT)格式, (D3DPOOL)存储池, &pBuffer,
			共享句柄
		);
		if(pBuffer)
		{
			_索引缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>* 索引缓冲区 = new _索引缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>(pBuffer, this);
			if(!索引缓冲区)
			{
				pBuffer->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出缓冲区 = 索引缓冲区;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建渲染目标(
		UINT 宽度,
		UINT 高度,
		像素格式 格式,
		多重采样类型 采样类型,
		DWORD 采样质量,
		BOOL 锁定表面,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面,
		HANDLE* 共享句柄= nullptr
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns = m_p原生接口->CreateRenderTarget(
			宽度, 高度, (D3DFORMAT)格式,
			(D3DMULTISAMPLE_TYPE)采样类型,
			采样质量, 锁定表面, &pSurface,
			共享句柄
		);
		if(pSurface)
		{
			_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 显存表面 = new _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>(pSurface, nullptr, this);
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建深度模板表面(
		UINT 宽度,
		UINT 高度,
		像素格式 格式,
		多重采样类型 采样类型,
		DWORD 采样质量,
		BOOL 自动丢弃,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面,
		HANDLE* 共享句柄= nullptr
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns = m_p原生接口->CreateDepthStencilSurface(
			宽度, 高度, (D3DFORMAT)格式,
			(D3DMULTISAMPLE_TYPE)采样类型,
			采样质量, 自动丢弃, &pSurface,
			共享句柄
		);
		if(pSurface)
		{
			_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 显存表面 = new _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>(pSurface, nullptr, this);
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::更新表面数据(
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 源表面,
		const RECT* 源区域,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 目标表面,
		const POINT* 目标位置
	)
	{
		return m_p原生接口->UpdateSurface(
			源表面->⚠获取原生指针(), 源区域,
			目标表面->⚠获取原生指针(), 目标位置
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	template<typename T纹理接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::更新纹理数据(
		T纹理接口* 源纹理,
		T纹理接口* 目标纹理
	)
	{
		return m_p原生接口->UpdateTexture(
			源纹理->⚠获取原生指针(),
			目标纹理->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取渲染目标数据(
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 源表面,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 目标表面
	)
	{
		return m_p原生接口->GetRenderTargetData(
			源表面->⚠获取原生指针(),
			目标表面->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取前台缓冲数据(
		UINT 交换链索引,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns = m_p原生接口->GetFrontBufferData(
			交换链索引, pSurface
		);
		if(pSurface)
		{
			_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 显存表面 = new _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>(pSurface, nullptr, this);
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::拉伸复制表面区域(
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 源表面,
		const RECT* 源区域,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 目标表面,
		const RECT* 目标区域,
		纹理过滤方式 过滤方式
	)
	{
		return m_p原生接口->StretchRect(
			源表面->⚠获取原生指针(), 源区域,
			目标表面->⚠获取原生指针(), 目标区域,
			(D3DTEXTUREFILTERTYPE)过滤方式
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::填充颜色(
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 目标表面,
		const RECT* 填充区域,
		颜色值 颜色
	)
	{
		return m_p原生接口->ColorFill(
			目标表面->⚠获取原生指针(), 填充区域,
			颜色
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建离屏表面(
		UINT 宽度,
		UINT 高度,
		像素格式 格式,
		资源池类型 存储池,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面,
		HANDLE* 共享句柄= nullptr
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns = m_p原生接口->CreateOffscreenPlainSurface(
			宽度, 高度, (D3DFORMAT)格式,
			(D3DPOOL)存储池, &pSurface,
			共享句柄
		);
		if(pSurface)
		{
			_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 显存表面 = new _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>(pSurface, nullptr, this);
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置渲染目标(
		DWORD 目标索引,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 渲染目标
	)
	{
		return m_p原生接口->SetRenderTarget(
			目标索引,
			渲染目标->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取渲染目标(
		DWORD 目标索引,
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns = m_p原生接口->GetRenderTarget(
			目标索引, &pSurface
		);
		if(pSurface)
		{
			_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 显存表面 = new _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>(pSurface, nullptr, this);
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置深度模板表面(
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 深度模板
	)
	{
		return m_p原生接口->SetDepthStencilSurface(
			深度模板->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取深度模板表面(
		_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns = m_p原生接口->GetDepthStencilSurface(
			&pSurface
		);
		if(pSurface)
		{
			_显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 显存表面 = new _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>(pSurface, nullptr, this);
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::开始渲染()
	{
		return m_p原生接口->BeginScene();
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::结束渲染()
	{
		return m_p原生接口->EndScene();
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::清空缓冲区(
		DWORD 区域数量,
		const D3DRECT* 清空区域数组,
		DWORD 清空标志,
		颜色值 清空颜色,
		float 深度值,
		DWORD 模板值
	)
	{
		return m_p原生接口->Clear(
			区域数量, 清空区域数组,
			清空标志, 清空颜色,
			深度值, 模板值
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置变换矩阵(
		变换矩阵 矩阵类型,
		const 矩阵* 矩阵
	)
	{
		return m_p原生接口->SetTransform(
			(D3DTRANSFORMSTATETYPE)矩阵类型,
			矩阵
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取变换矩阵(
		变换矩阵 矩阵类型,
		矩阵* 输出矩阵
	)
	{
		return m_p原生接口->GetTransform(
			(D3DTRANSFORMSTATETYPE)矩阵类型,
			输出矩阵
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::级联变换矩阵(
		变换矩阵 矩阵类型,
		const 矩阵* 矩阵
	)
	{
		return m_p原生接口->MultiplyTransform(
			(D3DTRANSFORMSTATETYPE)矩阵类型,
			矩阵
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置视口参数(
		const 视口参数* 视口参数
	)
	{
		return m_p原生接口->SetViewport(
			(D3DVIEWPORT9*)视口参数
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取视口参数(
		视口参数* 输出参数
	)
	{
		return m_p原生接口->GetViewport(
			(D3DVIEWPORT9*)输出参数
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置材质属性(
		const 材质* 材质
	)
	{
		return m_p原生接口->SetMaterial(
			(D3DMATERIAL9*)材质
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取材质属性(
		材质* 输出材质
	)
	{
		return m_p原生接口->GetMaterial(
			(D3DMATERIAL9*)输出材质
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置光源属性(
		DWORD 光源索引,
		const 光源* 光源参数
	)
	{
		return m_p原生接口->SetLight(
			光源索引,
			(D3DLIGHT9*)光源参数
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取光源属性(
		DWORD 光源索引,
		光源* 输出参数
	)
	{
		return m_p原生接口->GetLight(
			光源索引,
			(D3DLIGHT9*)输出参数
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::开关光源(
		DWORD 光源索引,
		BOOL 是否启用
	)
	{
		return m_p原生接口->LightEnable(
			光源索引,
			是否启用
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取光源状态(
		DWORD 光源索引,
		BOOL* 输出启用状态
	)
	{
		return m_p原生接口->GetLightEnable(
			光源索引,
			输出启用状态
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置裁剪平面(
		DWORD 平面索引,
		const float* 平面方程
	)
	{
		return m_p原生接口->SetClipPlane(
			平面索引,
			平面方程
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取裁剪平面(
		DWORD 平面索引,
		float* 输出方程
	)
	{
		return m_p原生接口->GetClipPlane(
			平面索引,
			输出方程
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置渲染状态(
		渲染状态 状态类型,
		DWORD 状态值
	)
	{
		return m_p原生接口->SetRenderState(
			(D3DRENDERSTATETYPE)状态类型,
			状态值
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取渲染状态(
		渲染状态 状态类型,
		DWORD* 输出状态值
	)
	{
		return m_p原生接口->GetRenderState(
			(D3DRENDERSTATETYPE)状态类型,
			输出状态值
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建状态块(
		状态块类型 类型,
		_状态块<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出状态块
	)
	{
		IDirect3DStateBlock9* pStateBlock= nullptr;
		HRESULT returns = m_p原生接口->CreateStateBlock(
			(D3DSTATEBLOCKTYPE)类型, &pStateBlock
		);
		if(pStateBlock)
		{
			_状态块<_显卡设备基类<T原生接口, T关联设备接口>>* 状态块 = new _状态块<_显卡设备基类<T原生接口, T关联设备接口>>(pStateBlock, this);
			if(!状态块)
			{
				pStateBlock->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出状态块 = 状态块;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::开始记录状态块()
	{
		return m_p原生接口->BeginStateBlock();
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::结束记录状态块(
		_状态块<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出状态块
	)
	{
		IDirect3DStateBlock9* pStateBlock= nullptr;
		HRESULT returns = m_p原生接口->EndStateBlock(&pStateBlock);
		if(pStateBlock)
		{
			_状态块<_显卡设备基类<T原生接口, T关联设备接口>>* 状态块 = new _状态块<_显卡设备基类<T原生接口, T关联设备接口>>(pStateBlock, this);
			if(!状态块)
			{
				pStateBlock->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出状态块 = 状态块;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置裁剪状态(
		const 裁剪状态* 状态参数
	)
	{
		return m_p原生接口->SetClipStatus(
			(const D3DCLIPSTATUS9*)状态参数
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取裁剪状态(
		裁剪状态* 输出状态
	)
	{
		return m_p原生接口->GetClipStatus(
			(D3DCLIPSTATUS9*)输出状态
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	template<typename T纹理接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取绑定纹理(
		DWORD 纹理阶段,
		T纹理接口** pp输出纹理
	)
	{
		if(!m_p绑定纹理)return false;
		*pp输出纹理= m_p绑定纹理;
		(*pp输出纹理)->增加引用();
		return S_OK;
	}

	template<typename T原生接口, typename T关联设备接口>
	template<typename T纹理接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::绑定纹理(
		DWORD 纹理阶段,
		T纹理接口* 纹理
	)
	{
		if(!纹理)return false;
		m_p绑定纹理= 纹理;

		return m_p原生接口->SetTexture(
			纹理阶段,
			纹理->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取纹理阶段状态(
		DWORD 纹理阶段,
		纹理阶段状态 状态类型,
		DWORD* 输出状态值
	)
	{
		return m_p原生接口->GetTextureStageState(
			纹理阶段,
			(D3DTEXTURESTAGESTATETYPE)状态类型,
			输出状态值
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置纹理阶段状态(
		DWORD 纹理阶段,
		纹理阶段状态 状态类型,
		DWORD 状态值
	)
	{
		return m_p原生接口->SetTextureStageState(
			纹理阶段,
			(D3DTEXTURESTAGESTATETYPE)状态类型,
			状态值
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取采样器状态(
		DWORD 采样器索引,
		采样器状态 状态类型,
		DWORD* 输出状态值
	)
	{
		return m_p原生接口->GetSamplerState(
			采样器索引,
			(D3DSAMPLERSTATETYPE)状态类型,
			输出状态值
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置采样器状态(
		DWORD 采样器索引,
		采样器状态 状态类型,
		DWORD 状态值
	)
	{
		return m_p原生接口->SetSamplerState(
			采样器索引,
			(D3DSAMPLERSTATETYPE)状态类型,
			状态值
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::验证设备支持(
		DWORD* 输出所需的渲染次数
	)
	{
		return m_p原生接口->ValidateDevice(
			输出所需的渲染次数
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置调色板颜色项(
		UINT 调色板编号,
		const PALETTEENTRY* 颜色数组 //WinGDI调色板
	)
	{
		return m_p原生接口->SetPaletteEntries(
			调色板编号,
			颜色数组
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取调色板颜色项(
		UINT 调色板编号,
		PALETTEENTRY* 输出颜色数组 //WinGDI调色板
	)
	{
		return m_p原生接口->GetPaletteEntries(
			调色板编号,
			输出颜色数组
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::激活调色板(
		UINT 调色板编号
	)
	{
		return m_p原生接口->SetCurrentTexturePalette(
			调色板编号
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取当前调色板(
		UINT* 输出调色板编号
	)
	{
		return m_p原生接口->GetCurrentTexturePalette(
			输出调色板编号
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置裁剪区域(
		const RECT* 裁剪区域
	)
	{
		return m_p原生接口->SetScissorRect(
			裁剪区域
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取裁剪区域(
		RECT* 输出裁剪区域
	)
	{
		return m_p原生接口->GetScissorRect(
			输出裁剪区域
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置软件顶点处理(
		BOOL 启用软件处理
	)
	{
		return m_p原生接口->SetSoftwareVertexProcessing(
			启用软件处理
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	BOOL _显卡设备基类<T原生接口, T关联设备接口>::是否使用软件顶点处理()const
	{
		return m_p原生接口->GetSoftwareVertexProcessing();
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置NURBS细分级别(
		float 细分段数
	)
	{
		return m_p原生接口->SetNPatchMode(
			细分段数
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	float _显卡设备基类<T原生接口, T关联设备接口>::获取当前细分级别()const
	{
		return m_p原生接口->GetNPatchMode();
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::绘制图元(
		图元 类型,
		UINT 起始顶点索引,
		UINT 图元数量
	)
	{
		return m_p原生接口->DrawPrimitive(
			(D3DPRIMITIVETYPE)类型,
			起始顶点索引,
			图元数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::绘制索引图元(
		图元 类型,
		INT 基准顶点偏移,
		UINT 最小顶点索引,
		UINT 使用顶点数,
		UINT 起始索引,
		UINT 图元数量
	)
	{
		return m_p原生接口->DrawIndexedPrimitive(
			(D3DPRIMITIVETYPE)类型,
			基准顶点偏移,
			最小顶点索引,
			使用顶点数,
			起始索引,
			图元数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::快速绘制图元(
		图元 类型,
		UINT 图元数量,
		const void* 顶点数据指针,
		UINT 顶点步长
	)
	{
		return m_p原生接口->DrawPrimitiveUP(
			(D3DPRIMITIVETYPE)类型,
			图元数量,
			顶点数据指针,
			顶点步长
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::快速绘制索引图元(
		图元 类型,
		UINT 最小顶点索引,
		UINT 使用顶点数,
		UINT 图元数量,
		const void* 索引数据指针,
		像素格式 格式,
		const void* 顶点数据指针,
		UINT 顶点步长
	)
	{
		return m_p原生接口->DrawIndexedPrimitiveUP(
			(D3DPRIMITIVETYPE)类型,
			最小顶点索引,
			使用顶点数,
			图元数量,
			索引数据指针,
			(D3DFORMAT)格式,
			顶点数据指针,
			顶点步长
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::处理顶点数据(
		UINT 源起始索引,
		UINT 目标索引,
		UINT 顶点数量,
		_顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>* 目标缓冲区,
		_顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>* 声明接口,
		DWORD 处理标志
	)
	{
		return m_p原生接口->ProcessVertices(
			源起始索引,
			目标索引,
			顶点数量,
			目标缓冲区->⚠获取原生指针(),
			声明接口->⚠获取原生指针(),
			处理标志
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建顶点声明(
		const 顶点元素定义* 元素数组,
		_顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出声明
	)
	{
		IDirect3DVertexDeclaration9* pVertexDeclaration= nullptr;
		HRESULT returns = m_p原生接口->CreateVertexDeclaration(
			(D3DVERTEXELEMENT9*)元素数组, &pVertexDeclaration
		);
		if(pVertexDeclaration)
		{
			_顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>* 顶点格式声明 = new _顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>(pVertexDeclaration, this);
			if(!顶点格式声明)
			{
				pVertexDeclaration->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出声明 = 顶点格式声明;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::绑定顶点声明(
		_顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>* 声明接口
	)
	{
		return m_p原生接口->SetVertexDeclaration(
			声明接口->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取当前顶点声明(
		_顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出声明
	)
	{
		IDirect3DVertexDeclaration9* pVertexDeclaration= nullptr;
		HRESULT returns = m_p原生接口->GetVertexDeclaration(
			&pVertexDeclaration
		);
		if(pVertexDeclaration)
		{
			_顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>* 顶点格式声明 = new _顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>(pVertexDeclaration, this);
			if(!顶点格式声明)
			{
				pVertexDeclaration->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出声明 = 顶点格式声明;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置FVF格式(
		DWORD FVF标志
	)
	{
		return m_p原生接口->SetFVF(
			FVF标志
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取当前FVF格式(
		DWORD* 输出标志
	)
	{
		return m_p原生接口->GetFVF(
			输出标志
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建顶点着色器(
		const DWORD* 着色器字节码,
		_顶点着色器<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出着色器
	)
	{
		IDirect3DVertexShader9* pVertexShader= nullptr;
		HRESULT returns = m_p原生接口->CreateVertexShader(
			着色器字节码, &pVertexShader
		);
		if(pVertexShader)
		{
			_顶点着色器<_显卡设备基类<T原生接口, T关联设备接口>>* 顶点着色器 = new _顶点着色器<_显卡设备基类<T原生接口, T关联设备接口>>(pVertexShader, this);
			if(!顶点着色器)
			{
				pVertexShader->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出着色器 = 顶点着色器;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::绑定顶点着色器(
		_顶点着色器<_显卡设备基类<T原生接口, T关联设备接口>>* 着色器
	)
	{
		return m_p原生接口->SetVertexShader(
			着色器->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取当前顶点着色器(
		_顶点着色器<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出着色器
	)
	{
		IDirect3DVertexShader9* pVertexShader= nullptr;
		HRESULT returns = m_p原生接口->GetVertexShader(
			&pVertexShader
		);
		if(pVertexShader)
		{
			_顶点着色器<_显卡设备基类<T原生接口, T关联设备接口>>* 顶点着色器 = new _顶点着色器<_显卡设备基类<T原生接口, T关联设备接口>>(pVertexShader, this);
			if(!顶点着色器)
			{
				pVertexShader->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出着色器 = 顶点着色器;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置顶点着色器浮点常量(
		UINT 起始寄存器,
		const float* 常量数据,
		UINT 四维向量数量
	)
	{
		return m_p原生接口->SetVertexShaderConstantF(
			起始寄存器,
			常量数据,
			四维向量数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取顶点着色器浮点常量(
		UINT 起始寄存器,
		float* 输出数据,
		UINT 四维向量数量
	)
	{
		return m_p原生接口->GetVertexShaderConstantF(
			起始寄存器,
			输出数据,
			四维向量数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置顶点着色器整型常量(
		UINT 起始寄存器,
		const int* 常量数据,
		UINT 四维向量数量
	)
	{
		return m_p原生接口->SetVertexShaderConstantI(
			起始寄存器,
			常量数据,
			四维向量数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取顶点着色器整型常量(
		UINT 起始寄存器,
		int* 输出数据,
		UINT 四维向量数量
	)
	{
		return m_p原生接口->GetVertexShaderConstantI(
			起始寄存器,
			输出数据,
			四维向量数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置顶点着色器布尔常量(
		UINT 起始寄存器,
		const BOOL* 常量数据,
		UINT 布尔数量
	)
	{
		return m_p原生接口->SetVertexShaderConstantB(
			起始寄存器,
			常量数据,
			布尔数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取顶点着色器布尔常量(
		UINT 起始寄存器,
		BOOL* 输出数据,
		UINT 布尔数量
	)
	{
		return m_p原生接口->GetVertexShaderConstantB(
			起始寄存器,
			输出数据,
			布尔数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置顶点流源(
		UINT 流编号,
		_顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>* 流数据,
		UINT 字节偏移量,
		UINT 顶点步长
	)
	{
		return m_p原生接口->SetStreamSource(
			流编号,
			流数据->⚠获取原生指针(),
			字节偏移量,
			顶点步长
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取顶点流源(
		UINT 流编号,
		_顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出流数据,
		UINT* 输出偏移量,
		UINT* 输出步长
	)
	{
		IDirect3DVertexBuffer9* pVertexBuffer= nullptr;
		HRESULT returns = m_p原生接口->GetStreamSource(
			流编号,
			&pVertexBuffer,
			输出偏移量,
			输出步长
		);
		if(pVertexBuffer)
		{
			_顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>* 顶点缓冲区 = new _顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>(pVertexBuffer, this);
			if(!顶点缓冲区)
			{
				pVertexBuffer->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出流数据 = 顶点缓冲区;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置顶点流频率(
		UINT 流编号,
		UINT 频率设置
	)
	{
		return m_p原生接口->SetStreamSourceFreq(
			流编号,
			频率设置
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取顶点流频率(
		UINT 流编号,
		UINT* 输出频率
	)
	{
		return m_p原生接口->GetStreamSourceFreq(
			流编号,
			输出频率
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置索引缓冲(
		_索引缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>* 索引数据
	)
	{
		return m_p原生接口->SetIndices(
			索引数据->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取索引缓冲(
		_索引缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出索引数据
	)
	{
		IDirect3DIndexBuffer9* pIndexBuffer= nullptr;
		HRESULT returns = m_p原生接口->GetIndices(
			&pIndexBuffer
		);
		if(pIndexBuffer)
		{
			_索引缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>* 索引缓冲区 = new _索引缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>(pIndexBuffer, this);
			if(!索引缓冲区)
			{
				pIndexBuffer->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出索引数据 = 索引缓冲区;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建像素着色器(
		const DWORD* 着色器字节码,
		_像素着色器<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出着色器
	)
	{
		IDirect3DPixelShader9* pPixelShader= nullptr;
		HRESULT returns = m_p原生接口->CreatePixelShader(
			着色器字节码, &pPixelShader
		);
		if(pPixelShader)
		{
			_像素着色器<_显卡设备基类<T原生接口, T关联设备接口>>* 像素着色器 = new _像素着色器<_显卡设备基类<T原生接口, T关联设备接口>>(pPixelShader, this);
			if(!像素着色器)
			{
				pPixelShader->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出着色器 = 像素着色器;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置像素着色器(
		_像素着色器<_显卡设备基类<T原生接口, T关联设备接口>>* 着色器
	)
	{
		return m_p原生接口->SetPixelShader(
			着色器->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取当前像素着色器(
		_像素着色器<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出着色器
	)
	{
		IDirect3DPixelShader9* pPixelShader= nullptr;
		HRESULT returns = m_p原生接口->GetPixelShader(
			&pPixelShader
		);
		if(pPixelShader)
		{
			_像素着色器<_显卡设备基类<T原生接口, T关联设备接口>>* 着色器 = new _像素着色器<_显卡设备基类<T原生接口, T关联设备接口>>(pPixelShader, this);
			if(!着色器)
			{
				pPixelShader->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出着色器 = 着色器;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置像素着色器浮点常量(
		UINT 起始寄存器,
		const float* 常量数据,
		UINT 四维向量数量
	)
	{
		return m_p原生接口->SetPixelShaderConstantF(
			起始寄存器,
			常量数据,
			四维向量数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取像素着色器浮点常量(
		UINT 起始寄存器,
		float* 输出数据,
		UINT 四维向量数量
	)
	{
		return m_p原生接口->GetPixelShaderConstantF(
			起始寄存器,
			输出数据,
			四维向量数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置像素着色器整型常量(
		UINT 起始寄存器,
		const int* 常量数据,
		UINT 四维向量数量
	)
	{
		return m_p原生接口->SetPixelShaderConstantI(
			起始寄存器,
			常量数据,
			四维向量数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取像素着色器整型常量(
		UINT 起始寄存器,
		int* 输出数据,
		UINT 四维向量数量
	)
	{
		return m_p原生接口->GetPixelShaderConstantI(
			起始寄存器,
			输出数据,
			四维向量数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::设置像素着色器布尔常量(
		UINT 起始寄存器,
		const BOOL* 常量数据,
		UINT 布尔数量
	)
	{
		return m_p原生接口->SetPixelShaderConstantB(
			起始寄存器,
			常量数据,
			布尔数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::获取像素着色器布尔常量(
		UINT 起始寄存器,
		BOOL* 输出数据,
		UINT 布尔数量
	)
	{
		return m_p原生接口->GetPixelShaderConstantB(
			起始寄存器,
			输出数据,
			布尔数量
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::绘制矩形面片(
		UINT 面片句柄,
		const float* 细分段数,
		const 矩形面片信息* 面片信息
	)
	{
		return m_p原生接口->DrawRectPatch(
			面片句柄,
			细分段数,
			(const D3DRECTPATCH_INFO*)面片信息
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::绘制三角面片(
		UINT 面片句柄,
		const float* 细分段数,
		const 三角面片信息* 面片信息
	)
	{
		return m_p原生接口->DrawTriPatch(
			面片句柄,
			细分段数,
			(const D3DTRIPATCH_INFO*)面片信息
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::删除面片(
		UINT 面片句柄
	)
	{
		return m_p原生接口->DeletePatch(
			面片句柄
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _显卡设备基类<T原生接口, T关联设备接口>::创建查询对象(
		查询类型 类型,
		_状态查询器<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出查询
	)
	{
		IDirect3DQuery9* pQuery= nullptr;
		HRESULT returns = m_p原生接口->CreateQuery(
			(D3DQUERYTYPE)类型, &pQuery
		);
		if(pQuery)
		{
			_状态查询器<_显卡设备基类<T原生接口, T关联设备接口>>* 查询器 = new _状态查询器<_显卡设备基类<T原生接口, T关联设备接口>>(pQuery, this);
			if(!查询器)
			{
				pQuery->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出查询 = 查询器;
		}
		return returns;
	}
#ifdef D3D_DEBUG_INFO
	template<typename T原生接口, typename T关联设备接口>
	void _显卡设备基类<T原生接口, T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_显卡设备基类
#pragma endregion

#pragma region _状态块
	template<typename T关联设备接口>
	HRESULT _状态块<T关联设备接口>::捕获当前状态()
	{
		return m_p原生接口->Capture();
	}

	template<typename T关联设备接口>
	HRESULT _状态块<T关联设备接口>::应用保存状态()
	{
		return m_p原生接口->Apply();
	}
#ifdef D3D_DEBUG_INFO
	template<typename T关联设备接口>
	void _状态块<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_状态块
#pragma endregion

#pragma region _交换链基类
	template<typename T原生接口, typename T关联设备接口>
	HRESULT _交换链基类<T原生接口, T关联设备接口>::提交呈现(
		const RECT* 源区域= nullptr,
		const RECT* 目标区域= nullptr,
		HWND 目标窗口= nullptr,
		const RGNDATA* 脏区域= nullptr,
		DWORD 标志= 0
	)
	{
		return m_p原生接口->Present(
			源区域,
			目标区域,
			目标窗口,
			脏区域,
			标志
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _交换链基类<T原生接口, T关联设备接口>::获取前台缓冲数据(
		_显存表面<_交换链基类<T原生接口, T关联设备接口>, T关联设备接口>* 目标表面
	)
	{
		return m_p原生接口->GetFrontBufferData(
			目标表面->⚠获取原生指针()
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _交换链基类<T原生接口, T关联设备接口>::获取后台缓冲区(
		UINT 缓冲区索引,
		后台缓冲类型 缓冲类型,
		_显存表面<_交换链基类<T原生接口, T关联设备接口>, T关联设备接口>** pp输出表面
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns = m_p原生接口->GetBackBuffer(
			缓冲区索引,
			(D3DBACKBUFFER_TYPE)缓冲类型, &pSurface
		);
		if(pSurface)
		{
			_显存表面<_交换链基类<T原生接口, T关联设备接口>, T关联设备接口>* 显存表面 = new _显存表面<_交换链基类<T原生接口, T关联设备接口>, T关联设备接口>(pSurface, this, this->获取关联设备());
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _交换链基类<T原生接口, T关联设备接口>::获取光栅状态(
		光栅状态* 输出状态
	)
	{
		return m_p原生接口->GetRasterStatus(
			(D3DRASTER_STATUS*)输出状态
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _交换链基类<T原生接口, T关联设备接口>::获取显示模式(
		显示模式* 输出模式
	)
	{
		return m_p原生接口->GetDisplayMode(
			(D3DDISPLAYMODE*)输出模式
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _交换链基类<T原生接口, T关联设备接口>::获取呈现参数(
		呈现参数* 输出参数
	)
	{
		return m_p原生接口->GetPresentParameters(
			(D3DPRESENT_PARAMETERS*)输出参数
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T原生接口, typename T关联设备接口>
	void _交换链基类<T原生接口, T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_交换链基类
#pragma endregion

#pragma region _图形资源
	template<typename T原生接口, typename T关联设备接口>
	HRESULT _图形资源<T原生接口, T关联设备接口>::设置私有数据(
		REFGUID 标识,
		const void* 数据,
		DWORD 数据大小,
		DWORD 标志
	)
	{
		return m_p原生接口->SetPrivateData(
			标识,
			数据,
			数据大小,
			标志
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _图形资源<T原生接口, T关联设备接口>::获取私有数据(
		REFGUID 标识,
		void* 输出数据,
		DWORD* 数据大小
	)
	{
		return m_p原生接口->GetPrivateData(
			标识,
			输出数据,
			数据大小
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _图形资源<T原生接口, T关联设备接口>::释放私有数据(
		REFGUID 标识
	)
	{
		return m_p原生接口->FreePrivateData(
			标识
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	DWORD _图形资源<T原生接口, T关联设备接口>::设置优先级(
		DWORD 新优先级
	)
	{
		return m_p原生接口->SetPriority(
			新优先级
		);
	}
	template<>
	DWORD _图形资源<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>::设置优先级(
		DWORD 新优先级
		)
	{
		return NULL;
	}
	template<>
	DWORD _图形资源<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>::设置优先级(
		DWORD 新优先级
		)
	{
		return NULL;
	}

	template<typename T原生接口, typename T关联设备接口>
	DWORD _图形资源<T原生接口, T关联设备接口>::获取优先级() const
	{
		return m_p原生接口->GetPriority();
	}
	template<>
	DWORD _图形资源<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>::获取优先级() const
	{
		return NULL;
	}
	template<>
	DWORD _图形资源<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>::获取优先级() const
	{
		return NULL;
	}

	template<typename T原生接口, typename T关联设备接口>
	void _图形资源<T原生接口, T关联设备接口>::预加载资源()
	{
		m_p原生接口->PreLoad();
	}
	template<>
	void _图形资源<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>::预加载资源()
	{
		NULL;
	}
	template<>
	void _图形资源<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>::预加载资源()
	{
		NULL;
	}

	template<typename T原生接口, typename T关联设备接口>
	资源类型 _图形资源<T原生接口, T关联设备接口>::获取资源类型() const
	{
		return (资源类型)m_p原生接口->GetType();
	}
	template<>
	资源类型 _图形资源<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>::获取资源类型() const
	{
		return 资源类型枚举大小标识;
	}
	template<>
	资源类型 _图形资源<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>::获取资源类型() const
	{
		return 资源类型枚举大小标识;
	}
//_图形资源
#pragma endregion

#pragma region _顶点格式声明
	template<typename T关联设备接口>
	HRESULT _顶点格式声明<T关联设备接口>::获取声明元素(
		顶点元素定义* 输出定义,
		UINT* 输出元素数量
	)
	{
		return m_p原生接口->GetDeclaration(
			(D3DVERTEXELEMENT9*)输出定义,
			输出元素数量
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T关联设备接口>
	void _顶点格式声明<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_顶点格式声明
#pragma endregion

#pragma region _顶点着色器
	template<typename T关联设备接口>
	HRESULT _顶点着色器<T关联设备接口>::获取字节码(
		void* 输出缓冲区,
		UINT* 数据大小
	)
	{
		return m_p原生接口->GetFunction(
			输出缓冲区,
			数据大小
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T关联设备接口>
	void _顶点着色器<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_顶点着色器
#pragma endregion

#pragma region _像素着色器
	template<typename T关联设备接口>
	HRESULT _像素着色器<T关联设备接口>::获取字节码(
		void* 输出缓冲区,
		UINT* 数据大小
	)
	{
		return m_p原生接口->GetFunction(
			输出缓冲区,
			数据大小
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T关联设备接口>
	void _像素着色器<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_像素着色器
#pragma endregion

#pragma region _基础纹理
	template<typename T原生接口, typename T关联设备接口>
	DWORD _基础纹理<T原生接口, T关联设备接口>::设置细节级别(
		DWORD 新级别
	)
	{
		return m_p原生接口->SetLOD(
			新级别
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	DWORD _基础纹理<T原生接口, T关联设备接口>::获取当前细节级别() const
	{
		return m_p原生接口->GetLOD();
	}

	template<typename T原生接口, typename T关联设备接口>
	DWORD _基础纹理<T原生接口, T关联设备接口>::获取Mip层级数量() const
	{
		return m_p原生接口->GetLevelCount();
	}

	template<typename T原生接口, typename T关联设备接口>
	HRESULT _基础纹理<T原生接口, T关联设备接口>::设置自动生成过滤方式(
		纹理过滤方式 过滤类型
	)
	{
		return m_p原生接口->SetAutoGenFilterType(
			(D3DTEXTUREFILTERTYPE)过滤类型
		);
	}

	template<typename T原生接口, typename T关联设备接口>
	纹理过滤方式 _基础纹理<T原生接口, T关联设备接口>::获取自动生成过滤方式() const
	{
		return (纹理过滤方式)m_p原生接口->GetAutoGenFilterType();
	}

	template<typename T原生接口, typename T关联设备接口>
	void _基础纹理<T原生接口, T关联设备接口>::生成Mip子层级()
	{
		m_p原生接口->GenerateMipSubLevels();
	}
#ifdef D3D_DEBUG_INFO
	template<typename T原生接口, typename T关联设备接口>
	void _基础纹理<T原生接口, T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_基础纹理
#pragma endregion

#pragma region _平面纹理
	template<typename T关联设备接口>
	HRESULT _平面纹理<T关联设备接口>::获取层级描述(
		UINT 层级索引,
		表面描述* 输出描述
	)
	{
		return m_p原生接口->GetLevelDesc(
			层级索引,
			(D3DSURFACE_DESC*)输出描述
		);
	}

	template<typename T关联设备接口>
	HRESULT _平面纹理<T关联设备接口>::获取表面层级(
		UINT 层级索引,
		_显存表面<_平面纹理<T关联设备接口>, T关联设备接口>** pp输出表面
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns = m_p原生接口->GetSurfaceLevel(
			层级索引, &pSurface
		);
		if(pSurface)
		{
			_显存表面<_平面纹理<T关联设备接口>, T关联设备接口>* 显存表面 = new _显存表面<_平面纹理<T关联设备接口>, T关联设备接口>(pSurface, this, this->获取关联设备());
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	template<typename T关联设备接口>
	HRESULT _平面纹理<T关联设备接口>::锁定矩形区域(
		UINT 层级索引,
		锁定矩形* 锁定信息,
		const RECT* 区域= nullptr,
		DWORD 标志= 0
	)
	{
		return m_p原生接口->LockRect(
			层级索引,
			(D3DLOCKED_RECT*)锁定信息,
			区域,
			标志
		);
	}

	template<typename T关联设备接口>
	HRESULT _平面纹理<T关联设备接口>::解锁矩形区域(
		UINT 层级索引
	)
	{
		return m_p原生接口->UnlockRect(
			层级索引
		);
	}

	template<typename T关联设备接口>
	HRESULT _平面纹理<T关联设备接口>::标记需更新区域(
		const RECT* 区域
	)
	{
		return m_p原生接口->AddDirtyRect(
			区域
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T关联设备接口>
	void _平面纹理<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_平面纹理
#pragma endregion

#pragma region _体积纹理
	template<typename T关联设备接口>
	HRESULT _体积纹理<T关联设备接口>::获取层级描述(
		UINT 层级索引,
		体积纹理描述* 输出描述
	)
	{
		return m_p原生接口->GetLevelDesc(
			层级索引,
			(D3DVOLUME_DESC*)输出描述
		);
	}

	template<typename T关联设备接口>
	HRESULT _体积纹理<T关联设备接口>::获取体积层级(
		UINT 层级索引,
		_三维体积<_体积纹理<T关联设备接口>, T关联设备接口>** pp输出体积
	)
	{
		IDirect3DVolume9* pVolume= nullptr;
		HRESULT returns = m_p原生接口->GetVolumeLevel(
			层级索引, &pVolume
		);
		if(pVolume)
		{
			_三维体积<_体积纹理<T关联设备接口>, T关联设备接口>* 三维体积 = new _三维体积<_体积纹理<T关联设备接口>, T关联设备接口>(pVolume, this, this->获取关联设备());
			if(!三维体积)
			{
				pVolume->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出体积 = 三维体积;
		}
		return returns;
	}

	template<typename T关联设备接口>
	HRESULT _体积纹理<T关联设备接口>::锁定三维区域(
		UINT 层级索引,
		锁定体积* 锁定信息,
		const 三维区域* 区域= nullptr,
		DWORD 锁定标志= 0
	)
	{
		return m_p原生接口->LockBox(
			层级索引,
			(D3DLOCKED_BOX*)锁定信息,
			(const D3DBOX*)区域,
			锁定标志
		);
	}

	template<typename T关联设备接口>
	HRESULT _体积纹理<T关联设备接口>::解锁三维区域(
		UINT 层级索引
	)
	{
		return m_p原生接口->UnlockBox(
			层级索引
		);
	}

	template<typename T关联设备接口>
	HRESULT _体积纹理<T关联设备接口>::标记需更新区域(
		const 三维区域* 脏区域
	)
	{
		return m_p原生接口->AddDirtyBox(
			(const D3DBOX*)脏区域
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T关联设备接口>
	void _体积纹理<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_体积纹理
#pragma endregion

#pragma region _立方体贴图
	template<typename T关联设备接口>
	HRESULT _立方体贴图<T关联设备接口>::获取层级描述(
		UINT 层级索引,
		表面描述* 输出描述
	)
	{
		return m_p原生接口->GetLevelDesc(
			层级索引,
			(D3DSURFACE_DESC*)输出描述
		);
	}

	template<typename T关联设备接口>
	HRESULT _立方体贴图<T关联设备接口>::获取立方体表面(
		立方体贴图面 面类型,
		UINT 层级索引,
		_显存表面<_立方体贴图<T关联设备接口>, T关联设备接口>** pp输出表面
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns = m_p原生接口->GetCubeMapSurface(
			(D3DCUBEMAP_FACES)面类型,
			层级索引, &pSurface
		);
		if(pSurface)
		{
			_显存表面<_立方体贴图<T关联设备接口>, T关联设备接口>* 显存表面 = new _显存表面<_立方体贴图<T关联设备接口>, T关联设备接口>(pSurface, this, this->获取关联设备());
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	template<typename T关联设备接口>
	HRESULT _立方体贴图<T关联设备接口>::锁定立方体面区域(
		立方体贴图面 面类型,
		UINT 层级索引,
		锁定矩形* 锁定信息,
		const RECT* 区域= nullptr,
		DWORD 锁定标志= 0
	)
	{
		return m_p原生接口->LockRect(
			(D3DCUBEMAP_FACES)面类型,
			层级索引,
			(D3DLOCKED_RECT*)锁定信息,
			区域,
			锁定标志
		);
	}

	template<typename T关联设备接口>
	HRESULT _立方体贴图<T关联设备接口>::解锁立方体面区域(
		立方体贴图面 面类型,
		UINT 层级索引
	)
	{
		return m_p原生接口->UnlockRect(
			(D3DCUBEMAP_FACES)面类型,
			层级索引
		);
	}

	template<typename T关联设备接口>
	HRESULT _立方体贴图<T关联设备接口>::标记需更新区域(
		立方体贴图面 面类型,
		const RECT* 脏区域 = nullptr
	)
	{
		return m_p原生接口->AddDirtyRect(
			(D3DCUBEMAP_FACES)面类型,
			脏区域
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T关联设备接口>
	void _立方体贴图<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_立方体贴图
#pragma endregion

#pragma region _顶点缓冲区
	template<typename T关联设备接口>
	HRESULT _顶点缓冲区<T关联设备接口>::锁定数据(
		UINT 起始偏移,
		UINT 锁定长度,
		void** pp输出数据,
		DWORD 锁定标志 = 0
	)
	{
		return m_p原生接口->Lock(
			起始偏移,
			锁定长度,
			pp输出数据,
			锁定标志
		);
	}

	template<typename T关联设备接口>
	HRESULT _顶点缓冲区<T关联设备接口>::解锁数据()
	{
		return m_p原生接口->Unlock();
	}

	template<typename T关联设备接口>
	HRESULT _顶点缓冲区<T关联设备接口>::获取缓冲区描述(
		顶点缓冲描述* 输出描述
	)
	{
		return m_p原生接口->GetDesc(
			(D3DVERTEXBUFFER_DESC*)输出描述
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T关联设备接口>
	void _顶点缓冲区<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_顶点缓冲区
#pragma endregion

#pragma region _索引缓冲区
	template<typename T关联设备接口>
	HRESULT _索引缓冲区<T关联设备接口>::锁定数据(
		UINT 起始偏移,
		UINT 锁定长度,
		void** pp输出数据,
		DWORD 锁定标志 = 0
	)
	{
		return m_p原生接口->Lock(
			起始偏移,
			锁定长度,
			pp输出数据,
			锁定标志
		);
	}

	template<typename T关联设备接口>
	HRESULT _索引缓冲区<T关联设备接口>::解锁数据()
	{
		return m_p原生接口->Unlock();
	}

	template<typename T关联设备接口>
	HRESULT _索引缓冲区<T关联设备接口>::获取缓冲区描述(
		索引缓冲描述* 输出描述
	)
	{
		return m_p原生接口->GetDesc(
			(D3DINDEXBUFFER_DESC*)输出描述
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T关联设备接口>
	void _索引缓冲区<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_索引缓冲区
#pragma endregion

#pragma region _显存表面
	template<typename T所属容器接口, typename T关联设备接口>
	HRESULT _显存表面<T所属容器接口, T关联设备接口>::获取所属容器(
		T所属容器接口** pp输出容器
	)
	{
		if(!m_p所属容器)return 错误_未找到;
		*pp输出容器 = m_p所属容器;
		m_p所属容器->增加引用();
		return S_OK;
	}
	template<>
	HRESULT _显存表面<void, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>::获取所属容器(void** pp输出容器)
	{
		return NULL;
	}
	template<>
	HRESULT _显存表面<void, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>::获取所属容器(void** pp输出容器)
	{
		return NULL;
	}

	template<typename T所属容器接口, typename T关联设备接口>
	HRESULT _显存表面<T所属容器接口, T关联设备接口>::获取描述信息(
		表面描述* 输出描述
	)
	{
		return m_p原生接口->GetDesc(
			(D3DSURFACE_DESC*)输出描述
		);
	}

	template<typename T所属容器接口, typename T关联设备接口>
	HRESULT _显存表面<T所属容器接口, T关联设备接口>::锁定表面(
		锁定矩形* 锁定信息,
		const RECT* 区域= nullptr,
		DWORD 锁定标志= 0
	)
	{
		return m_p原生接口->LockRect(
			(D3DLOCKED_RECT*)锁定信息,
			区域,
			锁定标志
		);
	}

	template<typename T所属容器接口, typename T关联设备接口>
	HRESULT _显存表面<T所属容器接口, T关联设备接口>::解锁表面()
	{
		return m_p原生接口->UnlockRect();
	}

	template<typename T所属容器接口, typename T关联设备接口>
	HRESULT _显存表面<T所属容器接口, T关联设备接口>::获取GDI上下文(
		HDC* pp输出上下文
	)
	{
		return m_p原生接口->GetDC(
			pp输出上下文
		);
	}

	template<typename T所属容器接口, typename T关联设备接口>
	HRESULT _显存表面<T所属容器接口, T关联设备接口>::释放GDI上下文(
		HDC 上下文
	)
	{
		return m_p原生接口->ReleaseDC(
			上下文
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T所属容器接口, typename T关联设备接口>
	void _显存表面<T所属容器接口, T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_显存表面
#pragma endregion

#pragma region _三维体积
	template<typename T所属容器接口, typename T关联设备接口>
	HRESULT _三维体积<T所属容器接口, T关联设备接口>::获取所属容器(
		T所属容器接口** pp输出容器
	)
	{
		if(!m_p所属容器)return 错误_未找到;
		*pp输出容器 = m_p所属容器;
		m_p所属容器->增加引用();
		return S_OK;
	}
	template<>
	HRESULT _三维体积<void, _显卡设备基类<IDirect3DDevice9,_显卡管理器基类<IDirect3D9>>>::获取所属容器(
			void** pp输出容器
	)
	{
		return NULL;
	}
	template<>
	HRESULT _三维体积<void, _显卡设备基类<IDirect3DDevice9Ex,_显卡管理器基类<IDirect3D9Ex>>>::获取所属容器(
			void** pp输出容器
	)
	{
		return NULL;
	}
	
	template<typename T所属容器接口, typename T关联设备接口>
	HRESULT _三维体积<T所属容器接口, T关联设备接口>::获取描述信息(
		体积纹理描述* 输出描述
	)
	{
		return m_p原生接口->GetDesc(
			(D3DVOLUME_DESC*)输出描述
		);
	}

	template<typename T所属容器接口, typename T关联设备接口>
	HRESULT _三维体积<T所属容器接口, T关联设备接口>::锁定盒体(
		锁定体积* 锁定信息,
		const 三维区域* 区域= nullptr,
		DWORD 锁定标志= 0
	)
	{
		return m_p原生接口->LockBox(
			(D3DLOCKED_BOX*)锁定信息,
			(const D3DBOX*)区域,
			锁定标志
		);
	}

	template<typename T所属容器接口, typename T关联设备接口>
	HRESULT _三维体积<T所属容器接口, T关联设备接口>::解锁盒体()
	{
		return m_p原生接口->UnlockBox();
	}
#ifdef D3D_DEBUG_INFO
	template<typename T所属容器接口, typename T关联设备接口>
	void _三维体积<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_三维体积
#pragma endregion

#pragma region _状态查询器
	template<typename T关联设备接口>
	查询类型 _状态查询器<T关联设备接口>::获取查询类型() const
	{
		return (查询类型)m_p原生接口->GetType();
	}

	template<typename T关联设备接口>
	DWORD _状态查询器<T关联设备接口>::获取数据大小() const
	{
		return m_p原生接口->GetDataSize();
	}

	template<typename T关联设备接口>
	HRESULT _状态查询器<T关联设备接口>::发起查询(
		DWORD 控制标志
	)
	{
		return m_p原生接口->Issue(
			控制标志
		);
	}

	template<typename T关联设备接口>
	HRESULT _状态查询器<T关联设备接口>::获取数据(
		void* 输出数据,
		DWORD 数据大小,
		DWORD 获取标志
	)
	{
		return m_p原生接口->GetData(
			输出数据,
			数据大小,
			获取标志
		);
	}
#ifdef D3D_DEBUG_INFO
	template<typename T关联设备接口>
	void _状态查询器<T关联设备接口>::同步调试信息()
	{
		NULL;
	}
#endif
//_状态查询器
#pragma endregion

#pragma region 显卡管理器Ex
	HRESULT 显卡管理器Ex::创建设备Ex(
		UINT 显卡索引,
		设备类型 设备类型,
		HWND 窗口句柄,
		DWORD 行为标志,
		呈现参数* 呈现参数,
		显卡设备Ex** pp输出设备接口
	)
	{
		IDirect3DDevice9Ex* pDevice= nullptr;
		HRESULT returns = m_p原生接口->CreateDeviceEx(
			显卡索引,
			(D3DDEVTYPE)设备类型,
			窗口句柄,
			行为标志,
			(D3DPRESENT_PARAMETERS*)呈现参数,
			nullptr,
			&pDevice
		);
		if(pDevice)
		{
			显卡设备Ex* 显卡设备 = new 显卡设备Ex(pDevice, this);
			if(!显卡设备)
			{
				pDevice->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出设备接口 = 显卡设备;
		}
		return returns;
	}

	UINT 显卡管理器Ex::获取显示模式数量Ex(
		UINT 显卡索引,
		显示模式过滤器* 模式
	) const
	{
		return m_p原生接口->GetAdapterModeCountEx(
			显卡索引,
			(D3DDISPLAYMODEFILTER*)模式
		);
	}

	HRESULT 显卡管理器Ex::枚举显示模式Ex(
		UINT 显卡索引,
		显示模式过滤器* 模式,
		UINT 模式索引,
		显示模式Ex* 输出模式
	)
	{
		return m_p原生接口->EnumAdapterModesEx(
			显卡索引,
			(D3DDISPLAYMODEFILTER*)模式,
			模式索引,
			(D3DDISPLAYMODEEX*)输出模式
		);
	}

	HRESULT 显卡管理器Ex::获取显卡LUID(
		UINT 显卡索引,
		LUID* 输出LUID
	)
	{
		return m_p原生接口->GetAdapterLUID(
			显卡索引,
			输出LUID
		);
	}
//显卡管理器Ex
#pragma endregion

#pragma region 显卡设备Ex
	HRESULT 显卡设备Ex::设置单色卷积核(
		UINT 宽度,
		UINT 高度,
		float* 行系数,
		float* 列系数
	)
	{
		return m_p原生接口->SetConvolutionMonoKernel(
			宽度,
			高度,
			行系数,
			列系数
		);
	}

	HRESULT 显卡设备Ex::组合矩形(
		_显存表面<void, 显卡设备Ex>* 源表面,
		_显存表面<void, 显卡设备Ex>* 目标表面,
		_顶点缓冲区<显卡设备Ex>* 源矩形数组,
		UINT 矩形数量,
		_顶点缓冲区<显卡设备Ex>* 目标位置数组,
		矩形组合操作 操作,
		int X偏移量, int Y偏移量
	)
	{
		return m_p原生接口->ComposeRects(
			源表面->⚠获取原生指针(),
			目标表面->⚠获取原生指针(),
			源矩形数组->⚠获取原生指针(),
			矩形数量,
			目标位置数组->⚠获取原生指针(),
			(D3DCOMPOSERECTSOP)操作,
			X偏移量,
			Y偏移量
		);
	}

	HRESULT 显卡设备Ex::呈现画面Ex(
		const RECT* 源区域,
		const RECT* 目标区域,
		HWND 目标窗口,
		const RGNDATA* 脏区域,
		DWORD 标志
	)
	{
		return m_p原生接口->PresentEx(
			源区域,
			目标区域,
			目标窗口,
			脏区域,
			标志
		);
	}

	HRESULT 显卡设备Ex::获取GPU线程优先级(
		int* 输出优先级
	)
	{
		return m_p原生接口->GetGPUThreadPriority(
			输出优先级
		);
	}

	HRESULT 显卡设备Ex::设置GPU线程优先级(
		int 新优先级
	)
	{
		return m_p原生接口->SetGPUThreadPriority(
			新优先级
		);
	}

	HRESULT 显卡设备Ex::等待垂直同步(
		UINT 交换链索引
	)
	{
		return m_p原生接口->WaitForVBlank(
			交换链索引
		);
	}
	
	template<typename T资源类型>
	HRESULT 显卡设备Ex::检查资源驻留(
		_基础纹理<T资源类型, 显卡设备Ex>** pp资源数组,
		UINT 资源数量
	)
	{
		if(!pp资源数组 || !资源数量)return E_INVALIDARG;
		IDirect3DResource9** ppResArray = new IDirect3DResource9*[资源数量];
		for(UINT i= 0; i<资源数量; i++)
		{
			ppResArray[i] = pp资源数组[i]->⚠获取原生指针();
			pp资源数组[i]->增加引用();
		}
		HRESULT returns= m_p原生接口->CheckResourceResidency(
			ppResArray,
			资源数量
		);
		for(UINT i= 0; i<资源数量; i++)
		{
			ppResArray[i]= nullptr;
			pp资源数组[i]->释放资源();
		}
		return returns;
	}

	HRESULT 显卡设备Ex::设置最大帧延迟(
		UINT 最大帧数
	)
	{
		return m_p原生接口->SetMaximumFrameLatency(
			最大帧数
		);
	}

	HRESULT 显卡设备Ex::获取最大帧延迟(
		UINT* 输出最大帧数
	)
	{
		return m_p原生接口->GetMaximumFrameLatency(
			输出最大帧数
		);
	}

	HRESULT 显卡设备Ex::检查设备状态(
		HWND 目标窗口句柄
	)
	{
		return m_p原生接口->CheckDeviceState(
			目标窗口句柄
		);
	}

	HRESULT 显卡设备Ex::创建渲染目标Ex(
		UINT 宽度,
		UINT 高度,
		像素格式 格式,
		多重采样类型 采样类型,
		DWORD 采样质量,
		BOOL 可锁定,
		_显存表面<void, 显卡设备Ex>** pp输出表面,
		HANDLE* 共享句柄,
		DWORD 使用标志
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns= m_p原生接口->CreateRenderTargetEx(
			宽度,
			高度,
			(D3DFORMAT)格式,
			(D3DMULTISAMPLE_TYPE)采样类型,
			采样质量,
			可锁定,
			&pSurface,
			共享句柄,
			使用标志
		);
		if(pSurface)
		{
			_显存表面<void, 显卡设备Ex>* 显存表面 = new _显存表面<void, 显卡设备Ex>(pSurface, nullptr, this);
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	HRESULT 显卡设备Ex::创建离屏表面Ex(
		UINT 宽度,
		UINT 高度,
		像素格式 格式,
		资源池类型 存储池,
		_显存表面<void, 显卡设备Ex>** pp输出表面,
		HANDLE* 共享句柄,
		DWORD 使用标志
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns= m_p原生接口->CreateOffscreenPlainSurfaceEx(
			宽度,
			高度,
			(D3DFORMAT)格式,
			(D3DPOOL)存储池,
			&pSurface,
			共享句柄,
			使用标志
		);
		if(pSurface)
		{
			_显存表面<void, 显卡设备Ex>* 显存表面 = new _显存表面<void, 显卡设备Ex>(pSurface, nullptr, this);
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	HRESULT 显卡设备Ex::创建深度模板表面Ex(
		UINT 宽度,
		UINT 高度,
		像素格式 格式,
		多重采样类型 采样类型,
		DWORD 采样质量,
		BOOL 自动丢弃,
		_显存表面<void, 显卡设备Ex>** pp输出表面,
		HANDLE* 共享句柄,
		DWORD 使用标志
	)
	{
		IDirect3DSurface9* pSurface= nullptr;
		HRESULT returns= m_p原生接口->CreateDepthStencilSurfaceEx(
			宽度,
			高度,
			(D3DFORMAT)格式,
			(D3DMULTISAMPLE_TYPE)采样类型,
			采样质量,
			自动丢弃,
			&pSurface,
			共享句柄,
			使用标志
		);
		if(pSurface)
		{
			_显存表面<void, 显卡设备Ex>* 显存表面 = new _显存表面<void, 显卡设备Ex>(pSurface, nullptr, this);
			if(!显存表面)
			{
				pSurface->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出表面 = 显存表面;
		}
		return returns;
	}

	HRESULT 显卡设备Ex::重置设备Ex(
		呈现参数* 新呈现参数,
		显示模式Ex* 显示模式
	)
	{
		return m_p原生接口->ResetEx(
			(D3DPRESENT_PARAMETERS*)新呈现参数,
			(D3DDISPLAYMODEEX*)显示模式
		);
	}

	HRESULT 显卡设备Ex::获取显示模式Ex(
		UINT 交换链索引,
		显示模式Ex* 显示模式,
		显示旋转* 旋转信息
	)
	{
		return m_p原生接口->GetDisplayModeEx(
			交换链索引,
			(D3DDISPLAYMODEEX*)显示模式,
			(D3DDISPLAYROTATION*)旋转信息
		);
	}
//显卡设备Ex
#pragma endregion

#pragma region 交换链Ex
	HRESULT 交换链Ex::获取最后呈现计数(
		UINT* 输出计数
	)
	{
		return m_p原生接口->GetLastPresentCount(
			输出计数
		);
	}

	HRESULT 交换链Ex::获取呈现统计(
		呈现统计* 输出统计
	)
	{
		return m_p原生接口->GetPresentStats(
			(D3DPRESENTSTATS*)输出统计
		);
	}

	HRESULT 交换链Ex::获取显示模式Ex(
		显示模式Ex* 输出模式,
		显示旋转* 输出旋转
	)
	{
		return m_p原生接口->GetDisplayModeEx(
			(D3DDISPLAYMODEEX*)输出模式,
			(D3DDISPLAYROTATION*)输出旋转
		);
	}
//交换链Ex
#pragma endregion

#pragma region 覆盖层
	HRESULT 覆盖层::检查设备覆盖层类型(
		UINT 显卡索引,
		设备类型 设备类型,
		UINT 覆盖层宽度,
		UINT 覆盖层高度,
		像素格式 覆盖层格式,
		显示模式Ex* 显示模式,
		显示旋转 旋转方向,
		覆盖层能力* 输出能力
	)
	{
		return m_p原生接口->CheckDeviceOverlayType(
			显卡索引,
			(D3DDEVTYPE)设备类型,
			覆盖层宽度,
			覆盖层高度,
			(D3DFORMAT)覆盖层格式,
			(D3DDISPLAYMODEEX*)显示模式,
			(D3DDISPLAYROTATION)旋转方向,
			(D3DOVERLAYCAPS*)输出能力
		);
	}
//覆盖层
#pragma endregion

#pragma region 视频设备
	HRESULT 视频设备::获取内容保护能力(
		CONST GUID* 加密类型,
		CONST GUID* 解码配置,
		内容保护能力* 能力描述
	)
	{
		return m_p原生接口->GetContentProtectionCaps(
			加密类型,
			解码配置,
			(D3DCONTENTPROTECTIONCAPS*)能力描述
		);
	}

	HRESULT 视频设备::创建认证通道(
		认证通道类型 通道类型,
		认证通道** pp输出通道,
		HANDLE* 通道句柄
		)
	{
		IDirect3DAuthenticatedChannel9* pChannel= nullptr;
		HRESULT returns= m_p原生接口->CreateAuthenticatedChannel(
			(D3DAUTHENTICATEDCHANNELTYPE)通道类型,
			&pChannel,
			通道句柄
		);
		if(pChannel)
		{
			认证通道* 通道 = new 认证通道(pChannel);
			if(!通道)
			{
				pChannel->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出通道 = 通道;
		}
		return returns;
	}

	HRESULT 视频设备::创建加密会话(
		CONST GUID* 加密类型,
		CONST GUID* 解码配置,
		加密会话** pp输出会话,
		HANDLE* 加密句柄
	)
	{
		IDirect3DCryptoSession9* pSession= nullptr;
		HRESULT returns= m_p原生接口->CreateCryptoSession(
			加密类型,
			解码配置,
			&pSession,
			加密句柄
		);
		if(pSession)
		{
			加密会话* 会话 = new 加密会话(pSession);
			if(!会话)
			{
				pSession->Release();
				return E_OUTOFMEMORY;
			}
			*pp输出会话 = 会话;
		}
		return returns;
	}
//视频设备
#pragma endregion

#pragma region 认证通道
	HRESULT 认证通道::获取证书大小(
		UINT* 证书大小
	)
	{
		return m_p原生接口->GetCertificateSize(
			证书大小
		);
	}

	HRESULT 认证通道::获取证书(
		UINT 证书大小,
		BYTE* 证书数据
	)
	{
		return m_p原生接口->GetCertificate(
			证书大小,
			证书数据
		);
	}

	HRESULT 认证通道::协商密钥交换(
		UINT 数据大小,
		VOID* 数据
	)
	{
		return m_p原生接口->NegotiateKeyExchange(
			数据大小,
			数据
		);
	}

	HRESULT 认证通道::查询(
		UINT 输入大小,
		CONST VOID* 输入数据,
		UINT 输出大小,
		VOID* 输出数据
	)
	{
		return m_p原生接口->Query(
			输入大小,
			输入数据,
			输出大小,
			输出数据
		);
	}

	HRESULT 认证通道::配置(
		UINT 输入大小,
		CONST VOID* 输入数据,
		认证通道配置输出* 输出配置
	)
	{
		return m_p原生接口->Configure(
			输入大小,
			输入数据,
			(D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT*)输出配置
		);
	}
//认证通道
#pragma endregion

#pragma region 加密会话
	HRESULT 加密会话::获取证书大小(
		UINT* 证书大小
	)
	{
		return m_p原生接口->GetCertificateSize(
			证书大小
		);
	}

	HRESULT 加密会话::获取证书(
		UINT 证书大小,
		BYTE* 证书数据
	)
	{
		return m_p原生接口->GetCertificate(
			证书大小,
			证书数据
		);
	}

	HRESULT 加密会话::协商密钥交换(
		UINT 数据大小,
		VOID* 数据
	)
	{
		return m_p原生接口->NegotiateKeyExchange(
			数据大小,
			数据
		);
	}

	HRESULT 加密会话::加密传输(
		_显存表面<加密会话, 显卡设备Ex>* 源表面,
		_显存表面<加密会话, 显卡设备Ex>* 目标表面,
		UINT 目标表面大小,
		VOID* 初始化向量
	)
	{
		return m_p原生接口->EncryptionBlt(
			源表面->⚠获取原生指针(),
			目标表面->⚠获取原生指针(),
			目标表面大小,
			初始化向量
		);
	}

	HRESULT 加密会话::解密传输(
		_显存表面<加密会话, 显卡设备Ex>* 源表面,
		_显存表面<加密会话, 显卡设备Ex>* 目标表面,
		UINT 源表面大小,
		加密块信息* 加密块信息,
		VOID* 内容密钥,
		VOID* 初始化向量
	)
	{
		return m_p原生接口->DecryptionBlt(
			源表面->⚠获取原生指针(),
			目标表面->⚠获取原生指针(),
			源表面大小,
			(D3DENCRYPTED_BLOCK_INFO*)加密块信息,
			内容密钥,
			初始化向量
		);
	}

	HRESULT 加密会话::获取表面间距(
		_显存表面<加密会话, 显卡设备Ex>* 源表面,
		UINT* 表面间距
	)
	{
		return m_p原生接口->GetSurfacePitch(
			源表面->⚠获取原生指针(),
			表面间距
		);
	}

	HRESULT 加密会话::开始会话密钥刷新(
		VOID* 随机数,
		UINT 随机数大小
	)
	{
		return m_p原生接口->StartSessionKeyRefresh(
			随机数,
			随机数大小
		);
	}

	HRESULT 加密会话::完成会话密钥刷新()
	{
		return m_p原生接口->FinishSessionKeyRefresh();
	}

	HRESULT 加密会话::获取加密传输密钥(
		VOID* 回读密钥,
		UINT 密钥大小
	)
	{
		return m_p原生接口->GetEncryptionBltKey(
			回读密钥,
			密钥大小
		);
	}
//加密会话
#pragma endregion

#pragma region 显示实例化模板
	// 你妈，VS2010对模板的支持有限
	// 本来应该直接通过实例某个最终类，自动实例父类
	// 结果沟槽的实例哪个模板类就只能用哪个模板类的东西
	// 比如我实例了 _显卡管理器基类<IDirect3D9>
	// 就不能使用 _通用基类 中定义的 释放资源() 函数
	// 程序会报告error LNK2001: 无法解析的外部符号
	// 除非我再定义 _通用基类<IDirect3D9, void>
	// 只能把所有实例化都声明一遍了
	template class _通用基类<IDirect3D9, void>;
	template class _通用基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>;
	template class _通用基类<IDirect3DStateBlock9, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DSwapChain9, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DVertexDeclaration9, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DVertexShader9, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DPixelShader9, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DTexture9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DVolumeTexture9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DCubeTexture9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DVertexBuffer9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DIndexBuffer9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DSurface9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _通用基类<IDirect3DQuery9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;

	template class _显卡管理器基类<IDirect3D9>;
	template class _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>;
	template class _状态块<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _交换链基类<IDirect3DSwapChain9, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	
	template class _图形资源<IDirect3DTexture9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _图形资源<IDirect3DVolumeTexture9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _图形资源<IDirect3DCubeTexture9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _图形资源<IDirect3DVertexBuffer9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _图形资源<IDirect3DIndexBuffer9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _图形资源<IDirect3DSurface9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _图形资源<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;

	template class _顶点格式声明<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _顶点着色器<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _像素着色器<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	
	template class _基础纹理<IDirect3DTexture9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _基础纹理<IDirect3DVolumeTexture9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _基础纹理<IDirect3DCubeTexture9,  _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;

	template class _平面纹理<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _体积纹理<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _立方体贴图<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _顶点缓冲区<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _索引缓冲区<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _显存表面<void, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _显存表面<_交换链基类<IDirect3DSwapChain9, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _显存表面<_平面纹理<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _显存表面<_立方体贴图<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _三维体积<void, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _三维体积<_体积纹理<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>, _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;
	template class _状态查询器<_显卡设备基类<IDirect3DDevice9, _显卡管理器基类<IDirect3D9>>>;

	#if !defined(D3D_DISABLE_9EX)
	template class _通用基类<IDirect3D9Ex, void>;
	template class _通用基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>;
	template class _通用基类<IDirect3DStateBlock9, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DSwapChain9, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DSwapChain9Ex, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DVertexDeclaration9, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DVertexShader9, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DPixelShader9, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DTexture9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DVolumeTexture9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DCubeTexture9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DVertexBuffer9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DIndexBuffer9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DSurface9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _通用基类<IDirect3DQuery9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;

	template class _显卡管理器基类<IDirect3D9Ex>;
	template class _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>;
	template class _状态块<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _交换链基类<IDirect3DSwapChain9, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _交换链基类<IDirect3DSwapChain9Ex, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	
	template class _图形资源<IDirect3DTexture9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _图形资源<IDirect3DVolumeTexture9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _图形资源<IDirect3DCubeTexture9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _图形资源<IDirect3DVertexBuffer9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _图形资源<IDirect3DIndexBuffer9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _图形资源<IDirect3DSurface9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _图形资源<IDirect3DVolume9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;

	template class _顶点格式声明<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _顶点着色器<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _像素着色器<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	
	template class _基础纹理<IDirect3DTexture9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _基础纹理<IDirect3DVolumeTexture9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _基础纹理<IDirect3DCubeTexture9,  _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;

	template class _平面纹理<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _体积纹理<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _立方体贴图<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _顶点缓冲区<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _索引缓冲区<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _显存表面<void, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _显存表面<_交换链基类<IDirect3DSwapChain9, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _显存表面<_交换链基类<IDirect3DSwapChain9Ex, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _显存表面<_平面纹理<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _显存表面<_立方体贴图<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _三维体积<void, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _三维体积<_体积纹理<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>, _显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;
	template class _状态查询器<_显卡设备基类<IDirect3DDevice9Ex, _显卡管理器基类<IDirect3D9Ex>>>;

	#endif
#pragma endregion

#pragma region 杂项
	_显卡管理器基类<IDirect3D9>* WINAPI 创建显卡管理器(UINT SDK版本){
	// 留给习惯 IDirect3D9* pd3d= Direct3DCreate9(SDK版本);形式代码的程序员。
	// 汉化版提供了如下的p管理器->初始化(SDK版本)方法，建议使用。
	_显卡管理器基类<IDirect3D9>* p管理器= new _显卡管理器基类<IDirect3D9>;
    if (!p管理器) return nullptr;
	if(p管理器->初始化(SDK版本))return p管理器;
	delete p管理器;
	return nullptr;
	}

	HRESULT WINAPI 创建显卡管理器Ex(
    UINT SDK版本,
    显卡管理器Ex** pp输出管理器
	)
	{
		*pp输出管理器 = new 显卡管理器Ex;
		if (!*pp输出管理器) return E_OUTOFMEMORY;
		return (*pp输出管理器)->初始化(SDK版本);
	}

#pragma endregion